home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / dev / misc / DigitalLibrary.lha / DigitalLibrary / Digital.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-10-07  |  8.7 KB  |  323 lines
  1. /*
  2. // ##########################################################################
  3. // ####                                                                  ####
  4. // ####     DigitalLibrary - An Amiga library for memory allocation      ####
  5. // ####    =========================================================     ####
  6. // ####                                                                  ####
  7. // #### Digital.c                                                        ####
  8. // ####                                                                  ####
  9. // #### Version 1.00  --  October 06, 2000                               ####
  10. // ####                                                                  ####
  11. // #### Copyright (C) 1992  Thomas Dreibholz                             ####
  12. // ####                     Molbachweg 7                                 ####
  13. // ####                     51674 Wiehl/Germany                          ####
  14. // ####                     EMail: Dreibholz@bigfoot.com                 ####
  15. // ####                     WWW:   http://www.bigfoot.com/~dreibholz     ####
  16. // ####                                                                  ####
  17. // ##########################################################################
  18. */
  19. /***************************************************************************
  20.  *                                                                         *
  21.  *   This program is free software; you can redistribute it and/or modify  *
  22.  *   it under the terms of the GNU General Public License as published by  *
  23.  *   the Free Software Foundation; either version 2 of the License, or     *
  24.  *   (at your option) any later version.                                   *
  25.  *                                                                         *
  26.  ***************************************************************************/
  27.  
  28.  
  29. #include <exec/types.h>
  30. #include <exec/nodes.h>
  31. #include <exec/memory.h>
  32. #include <exec/tasks.h>
  33.  
  34. #ifndef MEMF_NORM
  35. #define MEMF_NORM MEMF_CLEAR|MEMF_PUBLIC
  36. #endif
  37.  
  38. struct DRemember                  /* Zur Verkettung von Speicherlisten  */
  39. {
  40.  struct DRemember *NextRemember;  /* Zeiger auf nächste Liste */
  41.  ULONG MemorySize;                /* Größe des Speicherblocks */
  42.  ULONG MemoryBlock;                /* Zeiger auf Speicherblock */
  43. };
  44. struct DRememberHeader            /* Hauptstruktur der Verkettungsliste */
  45. {
  46.  struct DRemember *FirstRemember; /* Zeiger auf erste Liste   */
  47.  struct DRemember *LastRemember;  /* Zeiger auf letzte Liste  */
  48.  struct DRemember DRemember;      /* DRemember für 1. Block   */
  49. };
  50. struct DMemory                    /* Liste für unverkettete Blöcke      */
  51. {
  52.  ULONG MemorySize;                /* Größe des Blocks         */
  53.  UBYTE Bytes[];                   /* Speicherblock            */
  54. };
  55. struct DAddress                   /* Liste für unverkettete Blöcke bei  */
  56. {                                 /* AllocAddress()                     */
  57.  ULONG MemorySize;                /* Größe des Blocks           */
  58.  ULONG Align;                     /* 4 Bytes für gerade Adresse */
  59.  UBYTE Bytes[];                   /* Speicherblock              */
  60. };
  61. struct DMemHeader                 /* MemList-Verwaltung                 */
  62. {
  63.  struct MemHeader ExecHeader;     /* MemHeader-Struktur       */
  64.  struct MemChunk ExecChunk;       /* Erster MemChunk          */
  65. };
  66.  
  67. /* Routine für die D-Memory-Belegung */
  68. ULONG AllocDMemory(size,flags)
  69.  ULONG size;
  70.  ULONG flags;
  71. {
  72.  register struct DMemory *mem;
  73.  size+=4;
  74.  mem=AllocMem(size,flags);
  75.  if(mem==NULL) return(NULL);
  76.  mem->MemorySize=size;
  77.  return((ULONG)mem+4L);
  78. }
  79. /* ================================= */
  80.  
  81. ULONG AllocChipMem(size)
  82.  ULONG size;
  83. {
  84.  return(AllocDMemory(size,MEMF_CHIP|MEMF_NORM));
  85. }
  86. ULONG AllocFastMem(size)
  87.  ULONG size;
  88. {
  89.  return(AllocDMemory(size,MEMF_FAST|MEMF_NORM));
  90. }
  91. ULONG AllocMemory(size)
  92.  ULONG size;
  93. {
  94.  return(AllocDMemory(size,MEMF_FAST|MEMF_NORM));
  95. }
  96. VOID FreeMemory(mem)
  97.  struct DMemory *mem;
  98. {
  99.  mem=(struct DMemory *)((ULONG)mem-4L);
  100.  FreeMem(mem,mem->MemorySize);
  101. }
  102.  
  103. /* Routine für die DRemember-Belegung */
  104. ULONG AllocDRemember(size,flags)
  105.  ULONG size;
  106.  ULONG flags;
  107. {
  108.  REGISTER ULONG mem;
  109.  register struct Task *task;
  110.  register struct DRememberHeader *rh;
  111.  register struct DRemember *rm;
  112.  task=FindTask(NULL);
  113.  rh=task->tc_UserData;
  114.  if(rh==NULL)
  115.   {
  116.    rh=AllocMem(sizeof(struct DRememberHeader),MEMF_NORM);
  117.    if(rh==NULL) return(0L);
  118.    mem=AllocMem(size,flags);
  119.    if(mem==NULL) { FreeMem(rh,sizeof(struct DRememberHeader)); return(0L); }
  120.    Forbid();
  121.    rh->FirstRemember=&rh->DRemember;
  122.    rh->LastRemember=&rh->DRemember;
  123.    rh->DRemember.NextRemember=NULL;
  124.    rh->DRemember.MemorySize=size;
  125.    rh->DRemember.MemoryBlock=mem;
  126.    task->tc_UserData=rh;
  127.    Permit();
  128.    return(mem);
  129.   }
  130.  else
  131.   {
  132.    rm=AllocMem(sizeof(struct DRemember),MEMF_NORM);
  133.    if(rm==NULL) return(NULL);
  134.    mem=AllocMem(size,flags);
  135.    if(mem==NULL) { FreeMem(rm,sizeof(struct DRemember)); return(0L); }
  136.    rm->NextRemember=NULL;
  137.    rm->MemorySize=size;
  138.    rm->MemoryBlock=mem;
  139.    Forbid();
  140.    rh->LastRemember->NextRemember=rm;
  141.    rh->LastRemember=rm;
  142.    Permit();
  143.    return(mem);
  144.   }
  145. }
  146. /* ================================== */
  147.  
  148. ULONG AllocRChipMem(size)
  149.  ULONG size;
  150. {
  151.  return(AllocDRemember(size,MEMF_CHIP|MEMF_NORM));
  152. }
  153. ULONG AllocRFastMem(size)
  154.  ULONG size;
  155. {
  156.  return(AllocDRemember(size,MEMF_FAST|MEMF_NORM));
  157. }
  158. ULONG AllocRMemory(size)
  159.  ULONG size;
  160. {
  161.  return(AllocDRemember(size,MEMF_NORM));
  162. }
  163. VOID FreeRMemory()
  164. {
  165.  register struct Task *task;
  166.  register struct DRememberHeader *rh;
  167.  register struct DRemember *rm,*copy;
  168.  task=FindTask(NULL);
  169.  rh=task->tc_UserData;
  170.  if(rh!=NULL)
  171.   {
  172.    rm=rh->FirstRemember;
  173.    while(rm!=NULL)
  174.     {
  175.      copy=rm->NextRemember;
  176.      FreeMem(rm->MemoryBlock,rm->MemorySize);
  177.      FreeMem(rm,sizeof(struct DRemember));
  178.      rm=copy;
  179.     }
  180.    FreeMem(rh,8L);
  181.    task->tc_UserData=NULL;
  182.   }
  183. }
  184.  
  185. struct DMemHeader *CreateMemHeader(size,attr,pri,mem,name)
  186.  ULONG size;
  187.  ULONG attr;
  188.  ULONG pri;
  189.  ULONG mem;
  190.  UBYTE *name;
  191. {
  192.  register struct DMemHeader *hd;
  193.  hd=AllocMem(sizeof(struct DMemHeader),MEMF_NORM);
  194.  if(hd==NULL) return(NULL);
  195.  hd->ExecChunk.mc_Next=NULL;
  196.  hd->ExecChunk.mc_Bytes=size;
  197.  hd->ExecHeader.mh_Node.ln_Succ=NULL;
  198.  hd->ExecHeader.mh_Node.ln_Pred=NULL;
  199.  hd->ExecHeader.mh_Node.ln_Type=NT_MEMORY;
  200.  hd->ExecHeader.mh_Node.ln_Name=name;
  201.  hd->ExecHeader.mh_Node.ln_Pri=pri;
  202.  hd->ExecHeader.mh_Attributes=attr;
  203.  hd->ExecHeader.mh_First=&hd->ExecChunk;
  204.  hd->ExecHeader.mh_Lower=mem;
  205.  hd->ExecHeader.mh_Upper=mem+(ULONG)size;
  206.  hd->ExecHeader.mh_Free=size;
  207.  return(hd);
  208. }
  209. VOID DeleteMemHeader(hd)
  210.  struct DMemHeader *hd;
  211. {
  212.  FreeMem(hd,sizeof(struct DMemHeader));
  213. }
  214. ULONG AllocLMemory(hd,size)
  215.  struct DMemHeader *hd;
  216.  ULONG size;
  217. {
  218.  register struct DMemory *mem;
  219.  size+=4;
  220.  mem=Allocate(hd,size);
  221.  if(mem==NULL) return(0L);
  222.  mem->MemorySize=size;
  223.  return((ULONG)mem+4L);
  224. }
  225. VOID FreeLMemory(hd,mem)
  226.  struct DMemHeader *hd;
  227.  struct DMemory *mem;
  228. {
  229.  mem=(struct DMemory *)((ULONG)mem-4L);
  230.  Deallocate(hd,mem,mem->MemorySize);
  231. }
  232.  
  233. ULONG AvailChipMem()
  234. {
  235.  return(AvailMem(MEMF_CHIP));
  236. }
  237. ULONG AvailFastMem()
  238. {
  239.  return(AvailMem(MEMF_FAST));
  240. }
  241. ULONG AvailMemory()
  242. {
  243.  return(AvailMem(MEMF_PUBLIC));
  244. }
  245. ULONG AvailLMemory(hd)
  246.  struct DMemHeader *hd;
  247. {
  248.  return(hd->ExecHeader.mh_Free);
  249. }
  250.  
  251. /* ######### New functions added for Version 38 ######################### */
  252.  
  253. struct DRememberHeader *BackupRList()
  254. {
  255.  register struct Task *task;
  256.  task=FindTask(NULL);
  257.  return(task->tc_UserData);
  258. }
  259. VOID RestoreRList(rh)
  260.  struct DRememberHeader *rh;
  261. {
  262.  register struct Task *task;
  263.  task=FindTask(NULL);
  264.  task->tc_UserData=rh;
  265. }
  266.  
  267. ULONG AllocAddress(size,location)
  268.  ULONG size;
  269.  ULONG location;
  270. {
  271.  register struct DAddress *mem;
  272.  size+=8;
  273.  location-=8;
  274.  mem=AllocAbs(size,location);
  275.  if(mem==NULL) return(NULL);
  276.  mem->MemorySize=size;
  277.  return((ULONG)mem+8L);
  278. }
  279.  
  280. ULONG AllocRAddress(size,location)
  281.  ULONG size;
  282.  ULONG location;
  283. {
  284.  REGISTER ULONG mem;
  285.  register struct Task *task;
  286.  register struct DRememberHeader *rh;
  287.  register struct DRemember *rm;
  288.  task=FindTask(NULL);
  289.  rh=task->tc_UserData;
  290.  if(rh==NULL)
  291.   {
  292.    rh=AllocMem(sizeof(struct DRememberHeader),MEMF_NORM);
  293.    if(rh==NULL) return(0L);
  294.    mem=AllocAbs(size,location);
  295.    if(mem==NULL) { FreeMem(rh,sizeof(struct DRememberHeader)); return(0L); }
  296.    Forbid();
  297.    rh->FirstRemember=&rh->DRemember;
  298.    rh->LastRemember=&rh->DRemember;
  299.    rh->DRemember.NextRemember=NULL;
  300.    rh->DRemember.MemorySize=size;
  301.    rh->DRemember.MemoryBlock=mem;
  302.    task->tc_UserData=rh;
  303.    Permit();
  304.    return(mem);
  305.   }
  306.  else
  307.   {
  308.    rm=AllocMem(sizeof(struct DRemember),MEMF_NORM);
  309.    if(rm==NULL) return(NULL);
  310.    mem=AllocAbs(size,location);
  311.    if(mem==NULL) { FreeMem(rm,sizeof(struct DRemember)); return(0L); }
  312.    rm->NextRemember=NULL;
  313.    rm->MemorySize=size;
  314.    rm->MemoryBlock=mem;
  315.    Forbid();
  316.    rh->LastRemember->NextRemember=rm;
  317.    rh->LastRemember=rm;
  318.    Permit();
  319.    return(mem);
  320.   }
  321. }
  322.  
  323.